/**
 * @copyright Copyright (c) 2025 CSG Digital Grid Technology (Guangdong) Co., Ltd.
 * @author Chen Yongjie
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "test_cs_getopt.h"
#include "main.h"

// 声明被测试的静态函数
extern void help(void);

// 用于捕获标准输出的缓冲区
#define MAX_BUFFER_SIZE 1024
static char output_buffer[MAX_BUFFER_SIZE];
static int saved_stdout;

/**
 * @brief 重定向标准输出到缓冲区
 * 
 * 测试步骤：
 * 1. 刷新标准输出缓冲区
 * 2. 保存当前标准输出文件描述符
 * 3. 创建管道并重定向输出
 * 
 * 预期结果：
 * 1. 成功重定向输出到缓冲区
 * 2. 返回0表示成功，-1表示失败
 */
static int redirect_stdout(void) {
    fflush(stdout);
    saved_stdout = dup(STDOUT_FILENO);
    if (saved_stdout == -1) return -1;
    
    // 创建管道
    int pipefd[2];
    if (pipe(pipefd) == -1) return -1;
    
    // 将标准输出重定向到管道
    if (dup2(pipefd[1], STDOUT_FILENO) == -1) return -1;
    close(pipefd[1]);
    
    // 从管道读取数据
    memset(output_buffer, 0, MAX_BUFFER_SIZE);
    read(pipefd[0], output_buffer, MAX_BUFFER_SIZE - 1);
    close(pipefd[0]);
    
    return 0;
}

/**
 * @brief 恢复标准输出
 * 
 * 测试步骤：
 * 1. 刷新标准输出缓冲区
 * 2. 恢复原始标准输出
 * 3. 关闭保存的文件描述符
 * 
 * 预期结果：
 * 1. 成功恢复原始标准输出
 * 2. 不应该有资源泄漏
 */
static void restore_stdout(void) {
    fflush(stdout);
    dup2(saved_stdout, STDOUT_FILENO);
    close(saved_stdout);
}

/**
 * @brief 测试 help 函数的输出内容
 * 
 * 测试步骤：
 * 1. 准备预期的帮助信息文本
 * 2. 重定向标准输出
 * 3. 调用 help 函数
 * 
 * 预期结果：
 * 1. 输出内容应完全匹配预期文本
 * 2. 格式和内容应该正确
 */
void test_help_output(void) {
    // 预期的帮助信息文本
    const char *expected_output = "monitorctl { -h | -c | -m | -v | -i | -a } type\n\
-h		--help\n\
-v		--show-version\n\
-c		--show-cpu-usage\n\
-m		--show-memory-usage\n\
-i		--show-storage-usage\n\
-a		--show-all\n\
type	[host | container]\n";

    // 重定向标准输出
    if (redirect_stdout() == 0) {
        // 调用help函数
        help();
        
        // 恢复标准输出
        restore_stdout();
        
        // 验证输出内容
        CU_ASSERT_STRING_EQUAL(output_buffer, expected_output);
    } else {
        CU_FAIL("Failed to redirect stdout");
    }
}

/**
 * @brief 测试 help 函数在标准输出重定向失败时的行为
 * 
 * 测试步骤：
 * 1. 关闭标准输出
 * 2. 调用 help 函数
 * 3. 重新打开标准输出
 * 
 * 预期结果：
 * 1. 函数应该优雅地处理输出失败
 * 2. 不应该发生崩溃
 */
void test_help_stdout_failure(void) {
    // 关闭标准输出
    fclose(stdout);
    
    // 调用help函数
    help();
    
    // 重新打开标准输出
    stdout = fdopen(STDOUT_FILENO, "w");
    
    // 如果程序能继续执行到这里，说明help函数在输出失败时能够正常处理
    CU_PASS("Help function handled stdout failure gracefully");
}

/**
 * @brief 测试 help 函数的输出格式
 * 
 * 测试步骤：
 * 1. 重定向标准输出
 * 2. 调用 help 函数
 * 3. 检查输出的格式和缩进
 * 
 * 预期结果：
 * 1. 第一行应该以 "monitorctl" 开头
 * 2. 每个选项行应该以 "-" 开头
 * 3. 所有选项应该保持正确的缩进
 */
void test_help_format(void) {
    if (redirect_stdout() == 0) {
        help();
        restore_stdout();
        
        // 检查第一行格式
        char *first_line = strtok(output_buffer, "\n");
        CU_ASSERT_PTR_NOT_NULL(first_line);
        CU_ASSERT_TRUE(strstr(first_line, "monitorctl") == first_line);
        
        // 检查选项的缩进
        char *lines[8];
        int line_count = 0;
        char *line = strtok(NULL, "\n");
        while (line != NULL && line_count < 8) {
            lines[line_count++] = line;
            line = strtok(NULL, "\n");
        }
        
        // 验证每个选项行的格式
        for (int i = 0; i < line_count - 1; i++) {
            CU_ASSERT_TRUE(lines[i][0] == '-');
            CU_ASSERT_TRUE(strchr(lines[i], '-') != NULL);
        }
    } else {
        CU_FAIL("Failed to redirect stdout");
    }
}

/**
 * @brief 测试 getOptionParam 函数处理 -h 选项的情况
 * 
 * 测试步骤：
 * 1. 准备命令行参数 "-h"
 * 2. 重定向标准输出
 * 3. 调用 getOptionParam 函数
 * 
 * 预期结果：
 * 1. 函数应该返回 TRUE
 * 2. 输出应包含帮助信息
 * 3. 帮助信息应包含 "monitorctl" 和 "--help"
 */
void test_getOptionParam_help(void) {
    char *argv[] = {"monitorctl", "-h"};
    int argc = 2;
    
    // 重定向标准输出
    if (redirect_stdout() == 0) {
        // 调用被测试函数
        uint8_t result = getOptionParam(argc, argv);
        
        // 恢复标准输出
        restore_stdout();
        
        // 验证返回值
        CU_ASSERT_EQUAL(result, TRUE);
        
        // 验证输出内容包含帮助信息
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "monitorctl"));
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "--help"));
    } else {
        CU_FAIL("Failed to redirect stdout");
    }
}

/**
 * @brief 测试 getOptionParam 函数处理 -v 选项的情况
 * 
 * 测试步骤：
 * 1. 准备命令行参数 "-v"
 * 2. 重定向标准输出
 * 3. 调用 getOptionParam 函数
 * 
 * 预期结果：
 * 1. 函数应该返回 TRUE
 * 2. 输出应包含版本信息
 * 3. 版本信息应包含 "version: V"
 */
void test_getOptionParam_version(void) {
    char *argv[] = {"monitorctl", "-v"};
    int argc = 2;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "version: V"));
    } else {
        CU_FAIL("Failed to redirect stdout");
    }
}

/**
 * @brief 测试 getOptionParam 函数处理 -c 选项的 host 参数情况
 * 
 * 测试步骤：
 * 1. 准备命令行参数 "-c host"
 * 2. 重定向标准输出
 * 3. 调用 getOptionParam 函数
 * 
 * 预期结果：
 * 1. 函数应该返回 TRUE
 * 2. 输出应包含主机名和 CPU 使用率
 * 3. 输出格式应符合预期
 */
void test_getOptionParam_cpu_host(void) {
    char *argv[] = {"monitorctl", "-c", "host"};
    int argc = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "name: host"));
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "CPU usage:"));
    } else {
        CU_FAIL("Failed to redirect stdout");
    }
}

/**
 * @brief 测试 getOptionParam 函数处理 -c 选项的 container 参数情况
 * 
 * 测试步骤：
 * 1. 准备命令行参数 "-c container"
 * 2. 重定向标准输出
 * 3. 调用 getOptionParam 函数
 * 
 * 预期结果：
 * 1. 函数应该返回 TRUE
 * 2. 输出应包含容器数量信息
 * 3. 输出格式应符合预期
 */
void test_getOptionParam_cpu_container(void) {
    char *argv[] = {"monitorctl", "-c", "container"};
    int argc = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "container number"));
    } else {
        CU_FAIL("Failed to redirect stdout");
    }
}

/**
 * @brief 测试 getOptionParam 函数处理 -m 选项的 host 参数情况
 * 
 * 测试步骤：
 * 1. 准备命令行参数 "-m host"
 * 2. 重定向标准输出
 * 3. 调用 getOptionParam 函数
 * 
 * 预期结果：
 * 1. 函数应该返回 TRUE
 * 2. 输出应包含主机名和内存使用率
 * 3. 输出格式应符合预期
 */
void test_getOptionParam_memory_host(void) {
    char *argv[] = {"monitorctl", "-m", "host"};
    int argc = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "name: host"));
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "memory usage:"));
    } else {
        CU_FAIL("Failed to redirect stdout");
    }
}

/**
 * @brief 测试 getOptionParam 函数处理 -m 选项的 container 参数情况
 * 
 * 测试步骤：
 * 1. 准备命令行参数 "-m container"
 * 2. 重定向标准输出
 * 3. 调用 getOptionParam 函数
 * 
 * 预期结果：
 * 1. 函数应该返回 TRUE
 * 2. 输出应包含容器数量信息
 */
void test_getOptionParam_memory_container(void) {
    char *argv[] = {"monitorctl", "-m", "container"};
    int argc = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "container number"));
    } else {
        CU_FAIL("Failed to redirect stdout");
    }
}

/**
 * @brief 测试 getOptionParam 函数处理 -i 选项的 host 参数情况
 * 
 * 测试步骤：
 * 1. 准备命令行参数 "-i host"
 * 2. 重定向标准输出
 * 3. 调用 getOptionParam 函数
 * 
 * 预期结果：
 * 1. 函数应该返回 TRUE
 * 2. 输出应包含主机名和存储使用率
 * 3. 输出格式应符合预期
 */
void test_getOptionParam_storage_host(void) {
    char *argv[] = {"monitorctl", "-i", "host"};
    int argc = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "name: host"));
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "storage usage:"));
    } else {
        CU_FAIL("Failed to redirect stdout");
    }
}

/**
 * @brief 测试 getOptionParam 函数处理 -a 选项的 host 参数情况
 * 
 * 测试步骤：
 * 1. 准备命令行参数 "-a host"
 * 2. 重定向标准输出
 * 3. 调用 getOptionParam 函数
 * 
 * 预期结果：
 * 1. 函数应该返回 TRUE
 * 2. 输出应包含主机名和所有监控信息
 * 3. 输出应包含 CPU、内存和存储使用率
 */
void test_getOptionParam_all_host(void) {
    char *argv[] = {"monitorctl", "-a", "host"};
    int argc = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "name: host"));
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "CPU usage:"));
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "memory usage:"));
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "storage usage:"));
    } else {
        CU_FAIL("Failed to redirect stdout");
    }
}

/**
 * @brief 测试 getOptionParam 函数处理无效参数的情况
 * 
 * 测试步骤：
 * 1. 测试无参数情况
 * 2. 测试无效选项
 * 3. 测试无效参数值
 * 
 * 预期结果：
 * 1. 无参数时应返回 FALSE 并显示错误信息
 * 2. 无效选项时应显示帮助信息
 * 3. 无效参数值时应显示帮助信息
 */
void test_getOptionParam_invalid(void) {
    // 测试无参数情况
    char *argv1[] = {"monitorctl"};
    int argc1 = 1;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc1, argv1);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, FALSE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "Command parameter error"));
    }
    
    // 测试无效选项
    char *argv2[] = {"monitorctl", "-x"};
    int argc2 = 2;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc2, argv2);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "monitorctl"));
    }
    
    // 测试无效参数值
    char *argv3[] = {"monitorctl", "-c", "invalid"};
    int argc3 = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc3, argv3);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "monitorctl"));
    }
}

/**
 * @brief 测试 getOptionParam 函数在内存分配失败的情况
 * 
 * 测试步骤：
 * 1. 准备命令行参数
 * 2. 模拟内存分配失败
 * 3. 调用 getOptionParam 函数
 * 
 * 预期结果：
 * 1. 函数应该返回 FALSE
 * 2. 应该优雅地处理内存分配失败
 * 3. 不应发生段错误
 */
void test_getOptionParam_malloc_failure(void) {
    char *argv[] = {"monitorctl", "-c", "container"};
    int argc = 3;
    
    // 模拟内存分配失败
    // 这里需要使用某种方式来强制malloc返回NULL
    // 一种方法是通过LD_PRELOAD注入一个自定义的malloc函数
    // 或者使用包装函数来模拟内存分配失败
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, FALSE);
    }
}

/**
 * @brief 测试 getOptionParam 函数在参数值为空字符串的情况
 * 
 * 测试步骤：
 * 1. 准备带有空字符串参数的命令行参数
 * 2. 重定向标准输出
 * 3. 调用 getOptionParam 函数
 * 
 * 预期结果：
 * 1. 函数应该返回 TRUE
 * 2. 应该显示帮助信息
 * 3. 不应发生段错误
 */
void test_getOptionParam_empty_param(void) {
    char *argv[] = {"monitorctl", "-c", ""};
    int argc = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "monitorctl"));
    }
}

/**
 * @brief 测试 getOptionParam 函数处理所有选项组合的情况
 * 
 * 测试步骤：
 * 1. 准备所有可能的选项和参数组合
 * 2. 依次测试每个组合
 * 3. 验证输出结果
 * 
 * 预期结果：
 * 1. 所有组合都应该返回 TRUE
 * 2. 每个组合的输出都应符合预期格式
 * 3. 不应出现内存泄漏
 */
void test_getOptionParam_combinations(void) {
    struct {
        char *option;
        char *param;
        char *expected_output;
    } test_cases[] = {
        {"-c", "host", "CPU usage:"},
        {"-m", "host", "memory usage:"},
        {"-i", "host", "storage usage:"},
        {"-a", "host", "CPU usage:"},
        {"-c", "container", "container number"},
        {"-m", "container", "container number"},
        {"-i", "container", "container number"},
        {"-a", "container", "container number"}
    };
    
    for (int i = 0; i < sizeof(test_cases)/sizeof(test_cases[0]); i++) {
        char *argv[] = {"monitorctl", test_cases[i].option, test_cases[i].param};
        int argc = 3;
        
        if (redirect_stdout() == 0) {
            uint8_t result = getOptionParam(argc, argv);
            restore_stdout();
            
            CU_ASSERT_EQUAL(result, TRUE);
            CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, test_cases[i].expected_output));
        }
    }
}

/**
 * @brief 测试 getOptionParam 函数在系统调用失败的情况
 * 
 * 测试步骤：
 * 1. 准备命令行参数
 * 2. 模拟 docker 命令执行失败
 * 3. 调用 getOptionParam 函数
 * 4. 恢复 docker 命令权限
 * 
 * 预期结果：
 * 1. 函数应该返回 TRUE
 * 2. 输出应显示容器数量为0
 * 3. 不应发生崩溃
 */
void test_getOptionParam_syscall_failure(void) {
    char *argv[] = {"monitorctl", "-c", "container"};
    int argc = 3;
    
    // 模拟docker命令执行失败
    system("chmod -x /usr/bin/docker");
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_EQUAL(strstr(output_buffer, "container number :0") != NULL, 1);
    }
    
    // 恢复docker命令权限
    system("chmod +x /usr/bin/docker");
}

/**
 * @brief 测试 getOptionParam 函数在极限条件下的行为
 * 
 * 测试步骤：
 * 1. 准备命令行参数
 * 2. 创建模拟大量容器的测试脚本
 * 3. 调用 getOptionParam 函数
 * 4. 清理测试脚本
 * 
 * 预期结果：
 * 1. 函数应该返回 TRUE
 * 2. 输出缓冲区不应溢出
 * 3. 应正确处理大量容器信息
 */
void test_getOptionParam_boundary_conditions(void) {
    // 测试大量容器的情况
    char *argv[] = {"monitorctl", "-a", "container"};
    int argc = 3;
    
    // 创建临时的模拟docker脚本，输出大量容器信息
    FILE *fp = fopen("mock_docker.sh", "w");
    fprintf(fp, "#!/bin/bash\n");
    for (int i = 0; i < 100; i++) {
        fprintf(fp, "echo \"CONTAINER_%d 100%% 100%% 100GB\"\n", i);
    }
    fclose(fp);
    system("chmod +x mock_docker.sh");
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        // 验证输出缓冲区没有溢出
        CU_ASSERT_TRUE(strlen(output_buffer) < MAX_BUFFER_SIZE);
    }
    
    system("rm mock_docker.sh");
}

/**
 * @brief 测试 getOptionParam 函数处理-m选项的container参数情况
 */
/**
 * @brief 测试getOptionParam函数的状态清理功能
 * 
 * 测试步骤：
 * 1. 准备两组不同的命令行参数
 * 2. 连续调用两次 getOptionParam 函数
 * 3. 检查状态清理情况
 * 
 * 预期结果：
 * 1. 两次调用都应返回 TRUE
 * 2. dockerConfig 应被正确释放
 * 3. 不应有内存泄漏
 */
void test_getOptionParam_state_cleanup(void) {
    char *argv1[] = {"monitorctl", "-c", "container"};
    char *argv2[] = {"monitorctl", "-m", "container"};
    int argc = 3;
    
    // 连续调用两次，验证状态清理
    if (redirect_stdout() == 0) {
        uint8_t result1 = getOptionParam(argc, argv1);
        restore_stdout();
        
        uint8_t result2 = getOptionParam(argc, argv2);
        
        CU_ASSERT_EQUAL(result1, TRUE);
        CU_ASSERT_EQUAL(result2, TRUE);
        
        // 验证dockerConfig被正确释放
        CU_ASSERT_PTR_NULL(dockerConfig);
    }
}

/**
 * @brief 测试getOptionParam函数处理-i选项的container参数情况
 */
void test_getOptionParam_storage_container(void) {
    char *argv[] = {"monitorctl", "-i", "container"};
    int argc = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "container number"));
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "storage usage:"));
    } else {
        CU_FAIL("Failed to redirect stdout");
    }
}

/**
 * @brief 测试getOptionParam函数处理-a选项的container参数情况
 */
void test_getOptionParam_all_container(void) {
    char *argv[] = {"monitorctl", "-a", "container"};
    int argc = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "container number"));
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "CPU usage:"));
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "memory usage:"));
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "storage usage:"));
    } else {
        CU_FAIL("Failed to redirect stdout");
    }
}



/**
 * @brief 测试getOptionParam函数在无参数情况下的行为
 */
void test_getOptionParam_no_args(void) {
    char *argv[] = {"monitorctl"};
    int argc = 1;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, FALSE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "Command parameter error"));
    } else {
        CU_FAIL("Failed to redirect stdout");
    }
}

/**
 * @brief 测试getOptionParam函数在参数顺序错误的情况
 * 
 * 测试目标：验证函数对错误参数顺序的处理
 * 
 * 测试步骤：
 * 1. 准备参数顺序错误的命令行参数
 * 2. 调用getOptionParam函数
 * 3. 验证错误处理
 * 
 * 预期结果：
 * 1. 函数应该返回FALSE
 * 2. 应显示命令参数错误信息
 */
void test_getOptionParam_wrong_order(void) {
    char *argv[] = {"monitorctl", "host", "-c"};
    int argc = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, FALSE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "Command parameter error"));
    }
}

/**
 * @brief 测试getOptionParam函数在参数中包含多余空格的情况
 * 
 * 测试目标：验证函数对含有多余空格的参数的处理
 * 测试步骤：
 * 1. 准备包含多余空格的命令行参数
 * 2. 调用getOptionParam函数
 * 3. 验证处理结果
 * 
 * 预期结果：
 * 1. 函数应该正确处理并忽略多余空格
 * 2. 输出应符合预期格式
 */
void test_getOptionParam_extra_spaces(void) {
    char *argv[] = {"monitorctl", "-c", "  host  "};
    int argc = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "CPU usage:"));
    }
}

/**
 * @brief 测试getOptionParam函数在连续多次调用的情况
 * 
 * 测试目标：验证函数在连续调用时的稳定性
 * 测试步骤：
 * 1. 连续多次调用函数
 * 2. 每次使用不同的选项
 * 3. 验证所有调用的结果
 * 
 * 预期结果：
 * 1. 所有调用都应返回TRUE
 * 2. 每次调用的输出都应正确
 * 3. 不应有资源泄漏
 */
void test_getOptionParam_multiple_calls(void) {
    const char *options[] = {"-c", "-m", "-i", "-a"};
    const char *params[] = {"host", "container"};
    
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 2; j++) {
            char *argv[] = {"monitorctl", options[i], params[j]};
            int argc = 3;
            
            if (redirect_stdout() == 0) {
                uint8_t result = getOptionParam(argc, argv);
                restore_stdout();
                
                CU_ASSERT_EQUAL(result, TRUE);
            }
        }
    }
}

/**
 * @brief 测试getOptionParam函数在命令行参数包含非ASCII字符的情况
 * 
 * 测试目标：验证函数对非ASCII字符的处理
 * 测试步骤：
 * 1. 准备包含非ASCII字符的命令行参数
 * 2. 调用getOptionParam函数
 * 3. 验证处理结果
 * 
 * 预期结果：
 * 1. 函数应该正确处理或返回错误
 * 2. 不应发生崩溃
 */
void test_getOptionParam_non_ascii(void) {
    char *argv[] = {"monitorctl", "-c", "主机"};
    int argc = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "monitorctl"));
    }
}

/**
 * @brief 测试getOptionParam函数在快速切换不同选项的情况
 * 
 * 测试目标：验证函数在快速切换选项时的稳定性
 * 测试步骤：
 * 1. 快速切换不同选项调用函数
 * 2. 验证每次调用的结果
 * 
 * 预期结果：
 * 1. 所有调用都应正确处理
 * 2. 不应有资源泄漏或状态混淆
 */
void test_getOptionParam_rapid_switching(void) {
    struct {
        char *option;
        char *param;
    } test_cases[] = {
        {"-c", "host"},
        {"-m", "container"},
        {"-i", "host"},
        {"-a", "container"}
    };
    
    for (int i = 0; i < sizeof(test_cases)/sizeof(test_cases[0]); i++) {
        char *argv[] = {"monitorctl", test_cases[i].option, test_cases[i].param};
        int argc = 3;
        
        if (redirect_stdout() == 0) {
            uint8_t result = getOptionParam(argc, argv);
            restore_stdout();
            
            CU_ASSERT_EQUAL(result, TRUE);
        }
        
        // 添加短暂延时模拟快速切换
        usleep(100);
    }
}

/**
 * @brief 测试getOptionParam函数在命令行参数超长的情况
 * 
 * 测试目标：验证函数对超长参数的处理
 * 测试步骤：
 * 1. 准备超长的命令行参数
 * 2. 调用getOptionParam函数
 * 3. 验证处理结果
 * 
 * 预期结果：
 * 1. 函数应该正确处理或返回错误
 * 2. 不应发生缓冲区溢出
 */
void test_getOptionParam_long_arguments(void) {
    char long_param[1024];
    memset(long_param, 'a', sizeof(long_param)-1);
    long_param[sizeof(long_param)-1] = '\0';
    
    char *argv[] = {"monitorctl", "-c", long_param};
    int argc = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "monitorctl"));
    }
}

/**
 * @brief 测试getOptionParam函数在快速连续调用的情况
 * 
 * 测试目标：验证函数在快速连续调用时的稳定性
 * 测试步骤：
 * 1. 快速连续调用函数多次
 * 2. 每次使用不同的选项
 * 3. 验证所有调用的结果
 * 
 * 预期结果：
 * 1. 所有调用都应正确执行
 * 2. 不应出现资源泄漏
 * 3. 输出应保持一致性
 */
void test_getOptionParam_unicode_chars(void) {
    char *argv[] = {"monitorctl", "-c", "容器"};
    int argc = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "monitorctl"));
    }
}

void test_getOptionParam_max_length(void) {
    char long_param[4096];
    memset(long_param, 'A', sizeof(long_param)-1);
    long_param[sizeof(long_param)-1] = '\0';
    
    char *argv[] = {"monitorctl", "-c", long_param};
    int argc = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "monitorctl"));
    }
}

void test_getOptionParam_memory_management(void) {
    const int ITERATIONS = 100;
    char *argv[] = {"monitorctl", "-c", "container"};
    int argc = 3;
    
    for (int i = 0; i < ITERATIONS; i++) {
        if (redirect_stdout() == 0) {
            uint8_t result = getOptionParam(argc, argv);
            restore_stdout();
            
            CU_ASSERT_EQUAL(result, TRUE);
            CU_ASSERT_PTR_NULL(dockerConfig);
        }
    }
}

void test_getOptionParam_performance(void) {
    const int ITERATIONS = 1000;
    char *argv[] = {"monitorctl", "-c", "host"};
    int argc = 3;
    
    clock_t start = clock();
    
    for (int i = 0; i < ITERATIONS; i++) {
        if (redirect_stdout() == 0) {
            uint8_t result = getOptionParam(argc, argv);
            restore_stdout();
            
            CU_ASSERT_EQUAL(result, TRUE);
        }
    }
    
    clock_t end = clock();
    double cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    
    // 验证平均每次调用时间不超过1毫秒
    CU_ASSERT_TRUE(cpu_time_used / ITERATIONS < 0.001);
}

void test_getOptionParam_path_separators(void) {
    char *test_paths[] = {
        "container/test",
        "container\\test",
        "../container",
        "container/.."
    };
    
    for (int i = 0; i < sizeof(test_paths)/sizeof(test_paths[0]); i++) {
        char *argv[] = {"monitorctl", "-c", test_paths[i]};
        int argc = 3;
        
        if (redirect_stdout() == 0) {
            uint8_t result = getOptionParam(argc, argv);
            restore_stdout();
            
            CU_ASSERT_EQUAL(result, TRUE);
            CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "monitorctl"));
        }
    }
}

void test_getOptionParam_missing_env(void) {
    char *argv[] = {"monitorctl", "-c", "container"};
    int argc = 3;
    
    // 保存原始环境变量
    char *original_path = getenv("PATH");
    char *original_home = getenv("HOME");
    
    // 清除环境变量
    unsetenv("PATH");
    unsetenv("HOME");
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
    }
    
    // 恢复环境变量
    if (original_path) setenv("PATH", original_path, 1);
    if (original_home) setenv("HOME", original_home, 1);
}

/**
 * @brief 测试getOptionParam函数在环境变量影响下的行为
 * 
 * 测试目标：验证函数对环境变量的依赖性
 * 测试步骤：
 * 1. 修改相关环境变量
 * 2. 调用getOptionParam函数
 * 3. 恢复环境变量
 * 
 * 预期结果：
 * 1. 函数应该正确处理环境变量变化
 * 2. 不应受环境变量影响崩溃
 */
void test_getOptionParam_env_vars(void) {
    // 保存原始环境变量
    char *original_path = getenv("PATH");
    char *original_home = getenv("HOME");
    
    // 修改环境变量
    setenv("PATH", "/tmp", 1);
    setenv("HOME", "/nonexistent", 1);
    
    char *argv[] = {"monitorctl", "-c", "host"};
    int argc = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
    }
    
    // 恢复环境变量
    if (original_path) setenv("PATH", original_path, 1);
    if (original_home) setenv("HOME", original_home, 1);
}

/**
 * @brief 测试getOptionParam函数在文件系统满的情况
 * 
 * 测试目标：验证函数在文件系统资源受限时的行为
 * 测试步骤：
 * 1. 模拟文件系统满的情况
 * 2. 调用getOptionParam函数
 * 3. 恢复正常状态
 * 
 * 预期结果：
 * 1. 函数应该优雅处理资源限制
 * 2. 不应发生崩溃
 * 3. 应返回合适的错误信息
 */
void test_getOptionParam_filesystem_full(void) {
    // 创建一个临时目录并填满它
    system("mkdir -p /tmp/test_monitorctl");
    system("dd if=/dev/zero of=/tmp/test_monitorctl/bigfile bs=1M count=1024 2>/dev/null || true");
    
    char *argv[] = {"monitorctl", "-i", "host"};
    int argc = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
    }
    
    // 清理测试文件
    system("rm -rf /tmp/test_monitorctl");
}

/**
 * @brief 测试getOptionParam函数在命令行参数包含特殊字符的情况
 * 
 * 测试目标：验证函数对特殊字符的处理能力
 * 测试步骤：
 * 1. 准备包含特殊字符的命令行参数
 * 2. 调用getOptionParam函数
 * 3. 验证处理结果
 * 
 * 预期结果：
 * 1. 函数应该正确处理特殊字符
 * 2. 不应发生缓冲区溢出
 * 3. 应返回预期的输出
 */
void test_getOptionParam_special_chars(void) {
    char *special_chars[] = {
        "host!@#",
        "container$%^",
        "host&*()",
        "container+=-"
    };
    
    for (int i = 0; i < sizeof(special_chars)/sizeof(special_chars[0]); i++) {
        char *argv[] = {"monitorctl", "-c", special_chars[i]};
        int argc = 3;
        
        if (redirect_stdout() == 0) {
            uint8_t result = getOptionParam(argc, argv);
            restore_stdout();
            
            CU_ASSERT_EQUAL(result, TRUE);
            CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "monitorctl"));
        }
    }
}

/**
 * @brief 测试getOptionParam函数在命令行参数超长的情况
 * 
 * 测试目标：验证函数对超长参数的处理
 * 测试步骤：
 * 1. 准备超长的命令行参数
 * 2. 调用getOptionParam函数
 * 3. 验证处理结果
 * 
 * 预期结果：
 * 1. 函数应该正确处理或拒绝超长参数
 * 2. 不应发生缓冲区溢出
 * 3. 应保持系统稳定
 */
void test_getOptionParam_long_params(void) {
    char long_param[1024];
    memset(long_param, 'a', sizeof(long_param)-1);
    long_param[sizeof(long_param)-1] = '\0';
    
    char *argv[] = {"monitorctl", "-c", long_param};
    int argc = 3;
    
    if (redirect_stdout() == 0) {
        uint8_t result = getOptionParam(argc, argv);
        restore_stdout();
        
        CU_ASSERT_EQUAL(result, TRUE);
        CU_ASSERT_PTR_NOT_NULL(strstr(output_buffer, "monitorctl"));
    }
}
